Computers often contain internal devices, such as network cards and video cards, that may be detached from the I/O bus to which they are connected. For example, if a device malfunctions, it may be necessary to detach the device from the bus and to attach a new device to the bus. Similarly, it may be desirable to detach a device from the bus to replace the device with a different, superior, device.
Detaching a device from the I/O bus of an older computer system while the computer system was running would cause serious damage to the computer system. As a result, detaching a device from such a system required powering down the system, detaching the device (and replacing it with a new device, if appropriate), and powering up the system again. This was tedious and time-consuming. Furthermore, the computer system could not be used for other functions (such as running application programs that did not require the detached device) while it was powered down. This would decrease the productivity of the computer's users. If the computer was a server or other computer that was required for use by multiple users simultaneously, detaching a single device from the computer could disrupt the work being performed by all of those users.
As a result, techniques were developed which made it possible to detach and attach devices to a computer system while the system was running. This ability is referred to as “hotplugging” or “hotswapping” to indicate that the computer is “hot” (powered on) while devices are added to and removed from it.
ACPI (Advanced Configuration and Power Interface) is an open industry specification that is one example of a technology for facilitating hotplugging. ACPI defines a variety of firmware, hardware, and operating system interfaces for accomplishing system configuration, power management, plug 'n play, and a variety of other system-specific behaviors. For example, ACPI defines interfaces for performing hotplug of devices connected to PCI buses.
ACPI uses “general purpose events” (GPEs) for a variety of purposes, including signaling that the user desires to perform a hotplug. GPE events are typically implemented as follows. To signal the occurrence of an incident (such as the pressing of a doorbell) that should trigger a GPE event, a hardware device stores a predetermined value in a pre-designated hardware register in a block of registers referred to as a “GPE block.” This causes a GPE event to be generated and transmitted to the operating system. Each GPE is associated with a firmware method. In response to receiving a GPE event, the operating system executes the associated firmware method. For example, if the event is a doorbell event, then the associated method prepares the device from the corresponding slot to be added/removed.
Older versions of ACPI (such as version 1.0b) only supported a single GPE block, divided into two sub-blocks. Although a single GPE block may have been sufficient for small, single-partition computer systems, it often is not sufficient for multi-partition systems.
For example, a single GPE block, consisting of two sub-blocks, can support a maximum of two sets of 128 GPE events each. Such a GPE block can therefore support at most two cells, each with 128 GPEs. In a multi-partition computer, a partition may contain more than two cells in which GPEs occur, and the total number of events may exceed 256. In such a system, a single GPE block per partition is insufficient to support hotplug in all cells. In some systems, a single GPE block is provided in every cell to simplify wiring and configuration of partitions, but in such systems an operating system that supports older versions of ACPI can still only support hotplug events in a single one of the cells.
ACPI version 2.0 began to support multiple GPE blocks, thereby solving the problem just described. Some operating systems, such as variants of Unix (including the Linux and HP-UX® operating systems), support these newer versions of ACPI. Some operating systems, however, such as some versions of Microsoft Windows operating systems, do not support this and newer versions of ACPI, and therefore cannot take advantage of multiple GPE blocks.
A single computer may include a plurality of “cells,” each of which has its own processor, set of PCI slots, and other hardware. Such a computer may be logically subdivided into a plurality of partitions, each of which may include one or more cells. Consider, for example, a 16-cell computer that may be divided into 1, 2, 4, 8, or 16 partitions having 16, 8, 4, 2, or 1 cell each, respectively. Each partition in such a multi-partition computer may execute a different operating system, some of which support the newer versions of ACPI and some of which do not. Therefore, it is possible for a single complex to include a plurality of operating systems, some of which provide support for multiple GPE blocks and some of which do not.
Operating systems, such as Microsoft Windows operating systems, which support only a single GPE block, do not support “distributed GPEs,” which allow a GPE block in each cell. As a result, such operating systems do not support GPE events in more than two cells of a partition. (ACPI allows a single GPE block to be subdivided into two sub-blocks at two addresses, thereby effectively allowing two cells to have GPE blocks.)
Using conventional architectures, such operating systems do not support hotplug in more than two cells in a partition, because the required GPE events cannot be supported in all cells. It is desirable to support hotplug in all cells in a partition, regardless of the number of cells in the partition and the capabilities of the operating system executing in the partition. Furthermore, it is desirable to support hotplug in all cells of all partitions in a computer system, regardless of the number of partitions and the mixture of operating systems executing in those partitions.